package com.gzc.just.play.last.war.sceneserver.handler;

import com.gzc.just.play.last.war.common.handler.SimpleMessageHandler;
import com.gzc.just.play.last.war.sceneserver.service.BattleMessageRoutingService;
import io.netty.channel.ChannelHandlerContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 战斗消息处理器
 * 重构版本：使用BattleMessageRoutingService将消息路由到对应的处理组件
 * 处理与战斗相关的消息，如创建战斗、加入战斗、战斗操作等
 */
@Component
public class BattleMessageHandler implements SimpleMessageHandler {
    private static final Logger logger = LoggerFactory.getLogger(BattleMessageHandler.class);
    
    @Autowired
    private BattleMessageRoutingService battleMessageRoutingService;
    
    // 示例消息ID（实际应该从proto文件生成的枚举中获取）
    private static final int CREATE_BATTLE = 1001;
    private static final int JOIN_BATTLE = 1002;
    private static final int LEAVE_BATTLE = 1003;
    private static final int START_BATTLE = 1004;
    private static final int BATTLE_ACTION = 1005;
    
    @Override
    public void handle(Object message, ChannelHandlerContext ctx) throws Exception {
        handleMessage(message, ctx);
    }
    
    public void handleMessage(Object message, ChannelHandlerContext ctx) {
        try {
            // 从上下文中获取玩家ID
            io.netty.util.AttributeKey<Long> playerIdKey = io.netty.util.AttributeKey.valueOf("playerId");
            Long playerId = ctx.channel().attr(playerIdKey).get();
            if (playerId == null) {
                logger.error("Player ID not found in context, cannot process battle message");
                return;
            }
            
            // 将消息序列化为字节数组
            byte[] messageBytes = serializeMessage(message);
            
            // 获取消息类型
            int messageType = getMessageTypeFromMessage(message);
            
            // 使用消息路由服务处理消息
            boolean success = battleMessageRoutingService.routeGSMessage(ctx, messageType, messageBytes);
            
            if (!success) {
                logger.error("Failed to route battle message: messageType={}, playerId={}", messageType, playerId);
            }
            
        } catch (Exception e) {
            logger.error("Error handling battle message", e);
        }
    }
    
    // 以下为辅助方法，实际实现中应该根据具体的消息类型进行调整
    
    /**
     * 从消息对象中获取消息类型
     * 实际实现中应该根据具体的消息对象进行判断
     */
    private int getMessageTypeFromMessage(Object message) {
        // 实际实现中应该从消息对象中解析消息类型
        // 这里返回示例值
        return BATTLE_ACTION;
    }
    
    /**
     * 将消息对象序列化为字节数组
     * 实际实现中应该根据具体的消息类型进行序列化
     */
    private byte[] serializeMessage(Object message) {
        try {
            // 实际实现中应该根据具体的消息类型进行序列化
            // 这里返回示例值
            return new byte[0];
        } catch (Exception e) {
            logger.error("Failed to serialize message", e);
            return new byte[0];
        }
    }

    @Override
    public int getMessageId() {
        // 这里返回一个通用的消息ID，实际实现中应该为每个消息类型创建单独的处理器
        // 或者使用一个处理器处理多种消息类型
        return BATTLE_ACTION; // 示例：返回战斗操作消息ID
    }
    
    @Override
    public String getName() {
        return "BattleMessageHandler";
    }
    
    @Override
    public Logger getLogger() {
        return logger;
    }
}